/**
 * 日期工具函数
 * 专门处理ISO 8601格式时间（如 2025-06-10T15:21:03）的转换和格式化
 * 修复时区问题，确保正确处理东八区（GMT+8）时间
 * 
 * 使用示例：
 * 
 * // 1. 导入工具函数
 * import { formatDate, getCurrentChinaTime, isOverdue, createDate } from '../../utils/date'
 * 
 * // 2. 获取当前时间
 * const currentTime = getCurrentChinaTime() // "2025-01-15 14:30:25"
 * 
 * // 3. 格式化日期显示
 * const serverTime = "2025-01-15 10:30:00"
 * const relativeTime = formatDate(serverTime, 'relative') // "今天 10:30"
 * const dateTime = formatDate(serverTime, 'datetime') // "01-15 10:30"
 * const dateOnly = formatDate(serverTime, 'date') // "01-15"
 * const timeOnly = formatDate(serverTime, 'time') // "10:30"
 * 
 * // 4. 判断超时
 * const todo = { dueDate: "2025-01-14", dueTime: "18:00", completed: false }
 * const overdue = isOverdue(todo) // true/false
 * 
 * // 5. 安全创建日期对象
 * const dateObj = createDate("2025-01-15 14:30:00") // Date对象，正确处理时区
 * 
 * // 6. 在Vue组件中使用
 * export default {
 *   methods: {
 *     getCurrentTime() {
 *       return getCurrentChinaTime()
 *     },
 *     formatTodoTime(todo) {
 *       return formatDate(todo.createTime, 'relative')
 *     }
 *   }
 * }
 */

/**
 * 安全解析日期字符串，处理时区问题
 * @param {string} dateStr - 日期字符串
 * @returns {Date} 解析后的日期对象
 */
const parseDate = (dateStr) => {
  if (!dateStr) return null;
  
  // 如果是 ISO 8601 格式但没有时区信息，假设是本地时间
  if (typeof dateStr === 'string') {
    // 更强力的清理字符串，移除所有无效字符
    let cleaned = dateStr.trim();
    
    // 移除开头的逗号和空格
    cleaned = cleaned.replace(/^[,\s]+/, '');
    // 移除结尾的逗号和空格
    cleaned = cleaned.replace(/[,\s]+$/, '');
    
    // 如果清理后为空，返回null
    if (!cleaned) {
      return null;
    }
    
    // 如果只是时间部分（如：10:00:00），返回null
    if (/^\d{1,2}:\d{2}:\d{2}$/.test(cleaned)) {
      return null;
    }
    
    // 使用清理后的字符串
    dateStr = cleaned;
    
    // 处理后端返回的格式：yyyy-MM-dd HH:mm:ss
    if (/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2}$/.test(dateStr)) {
      // 直接解析为本地时间，不添加时区信息
      return new Date(dateStr);
    }
    
    // 处理只有日期的格式：yyyy-MM-dd
    if (/^\d{4}-\d{2}-\d{2}$/.test(dateStr)) {
      // 避免时区偏移问题，使用本地时间构造
      const parts = dateStr.split('-');
      return new Date(parseInt(parts[0]), parseInt(parts[1]) - 1, parseInt(parts[2]));
    }
    
    // 处理 ISO 格式，如果没有时区信息则不添加时区
    if (/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}$/.test(dateStr)) {
      return new Date(dateStr);
    }
  }
  
  // 其他格式直接解析
  return new Date(dateStr);
};

/**
 * 格式化日期显示
 * @param {string} dateStr - ISO 8601格式的时间字符串
 * @param {string} format - 格式类型：'relative'(相对时间) | 'datetime'(日期时间) | 'date'(仅日期) | 'time'(仅时间)
 * @returns {string} 格式化后的时间字符串
 */
export const formatDate = (dateStr, format = 'relative') => {
  if (!dateStr) return '';
  
  // 使用安全解析函数
  const date = parseDate(dateStr);
  
  // 检查日期是否有效
  if (!date || isNaN(date.getTime())) {
    // 只在开发模式下显示详细的警告信息
    if (process.env.NODE_ENV === 'development') {
      console.warn('无效的日期格式:', dateStr);
    }
    return ''; // 返回空字符串而不是原始字符串，避免显示异常
  }
  
  const now = new Date();
  
  switch (format) {
    case 'relative':
      return formatRelativeTime(date, now);
    case 'datetime':
      return formatDateTime(date, now);
    case 'date':
      return formatDateOnly(date, now);
    case 'time':
      return formatTimeOnly(date);
    default:
      return formatRelativeTime(date, now);
  }
};

/**
 * 格式化相对时间（如：今天 15:21、昨天、3天前）
 */
const formatRelativeTime = (date, now) => {
  const today = new Date(now.getFullYear(), now.getMonth(), now.getDate());
  const targetDate = new Date(date.getFullYear(), date.getMonth(), date.getDate());
  const diffTime = today - targetDate;
  const diffDays = Math.floor(diffTime / (1000 * 60 * 60 * 24));
  
  if (diffDays === 0) {
    // 今天 - 显示具体时间
    const hours = date.getHours().toString().padStart(2, '0');
    const minutes = date.getMinutes().toString().padStart(2, '0');
    return `今天 ${hours}:${minutes}`;
  } else if (diffDays === 1) {
    const hours = date.getHours().toString().padStart(2, '0');
    const minutes = date.getMinutes().toString().padStart(2, '0');
    return `昨天 ${hours}:${minutes}`;
  } else if (diffDays === -1) {
    const hours = date.getHours().toString().padStart(2, '0');
    const minutes = date.getMinutes().toString().padStart(2, '0');
    return `明天 ${hours}:${minutes}`;
  } else if (diffDays > 1 && diffDays < 7) {
    return `${diffDays}天前`;
  } else if (diffDays < -1 && diffDays > -7) {
    return `${Math.abs(diffDays)}天后`;
  } else {
    // 超过一周，显示具体日期
    return formatDateOnly(date, now);
  }
};

/**
 * 格式化完整日期时间（如：2025-06-10 15:21）
 */
const formatDateTime = (date, now) => {
  const year = date.getFullYear();
  const month = (date.getMonth() + 1).toString().padStart(2, '0');
  const day = date.getDate().toString().padStart(2, '0');
  const hours = date.getHours().toString().padStart(2, '0');
  const minutes = date.getMinutes().toString().padStart(2, '0');
  
  // 如果是今年，不显示年份
  if (year === now.getFullYear()) {
    return `${month}-${day} ${hours}:${minutes}`;
  } else {
    return `${year}-${month}-${day} ${hours}:${minutes}`;
  }
};

/**
 * 格式化日期（如：06-10 或 2025-06-10）
 */
const formatDateOnly = (date, now) => {
  const year = date.getFullYear();
  const month = (date.getMonth() + 1).toString().padStart(2, '0');
  const day = date.getDate().toString().padStart(2, '0');
  
  // 如果是今年，不显示年份
  if (year === now.getFullYear()) {
    return `${month}-${day}`;
  } else {
    return `${year}-${month}-${day}`;
  }
};

/**
 * 格式化时间（如：15:21）
 */
const formatTimeOnly = (date) => {
  const hours = date.getHours().toString().padStart(2, '0');
  const minutes = date.getMinutes().toString().padStart(2, '0');
  return `${hours}:${minutes}`;
};

/**
 * 获取友好的时间描述
 * @param {string} dateStr - ISO 8601格式的时间字符串
 * @returns {string} 友好的时间描述
 */
export const getTimeAgo = (dateStr) => {
  if (!dateStr) return '';
  
  const date = parseDate(dateStr);
  if (!date || isNaN(date.getTime())) return dateStr;
  
  const now = new Date();
  const diffTime = now - date;
  const diffMinutes = Math.floor(diffTime / (1000 * 60));
  const diffHours = Math.floor(diffTime / (1000 * 60 * 60));
  const diffDays = Math.floor(diffTime / (1000 * 60 * 60 * 24));
  
  if (diffMinutes < 1) {
    return '刚刚';
  } else if (diffMinutes < 60) {
    return `${diffMinutes}分钟前`;
  } else if (diffHours < 24) {
    return `${diffHours}小时前`;
  } else if (diffDays < 30) {
    return `${diffDays}天前`;
  } else if (diffDays < 365) {
    const diffMonths = Math.floor(diffDays / 30);
    return `${diffMonths}个月前`;
  } else {
    const diffYears = Math.floor(diffDays / 365);
    return `${diffYears}年前`;
  }
};

/**
 * 检查是否是今天
 */
export const isToday = (dateStr) => {
  if (!dateStr) return false;
  const date = parseDate(dateStr);
  if (!date) return false;
  const today = new Date();
  return date.toDateString() === today.toDateString();
};

/**
 * 检查是否是昨天
 */
export const isYesterday = (dateStr) => {
  if (!dateStr) return false;
  const date = parseDate(dateStr);
  if (!date) return false;
  const yesterday = new Date();
  yesterday.setDate(yesterday.getDate() - 1);
  return date.toDateString() === yesterday.toDateString();
};

/**
 * 检查是否是明天
 */
export const isTomorrow = (dateStr) => {
  if (!dateStr) return false;
  const date = parseDate(dateStr);
  if (!date) return false;
  const tomorrow = new Date();
  tomorrow.setDate(tomorrow.getDate() + 1);
  return date.toDateString() === tomorrow.toDateString();
};

/**
 * 将ISO格式时间转换为本地时间字符串
 * @param {string} isoString - ISO 8601格式时间字符串
 * @returns {string} 本地时间字符串
 */
export const isoToLocal = (isoString) => {
  if (!isoString) return '';
  const date = parseDate(isoString);
  if (!date || isNaN(date.getTime())) return isoString;
  
  return date.toLocaleString('zh-CN', {
    year: 'numeric',
    month: '2-digit',
    day: '2-digit',
    hour: '2-digit',
    minute: '2-digit',
    second: '2-digit'
  });
};

/**
 * 判断任务是否已过期
 * @param {Object} todo - 待办事项对象
 * @returns {boolean} 是否已过期
 */
export const isOverdue = (todo) => {
  if (!todo || todo.completed) return false;
  
  const now = new Date();
  let targetDate;
  
  // 处理不同格式的日期时间
  if (todo.dueDate && todo.dueTime) {
    // 新格式：分别存储日期和时间
    targetDate = parseDate(`${todo.dueDate} ${todo.dueTime}`);
  } else if (todo.dueTime) {
    // 旧格式：dueTime 包含完整的日期时间信息
    targetDate = parseDate(todo.dueTime);
  } else if (todo.dueDate) {
    // 只有日期，设置为当天结束时间
    targetDate = parseDate(todo.dueDate);
    if (targetDate) {
      targetDate.setHours(23, 59, 59, 999);
    }
  } else {
    return false;
  }
  
  // 检查日期是否有效
  if (!targetDate || isNaN(targetDate.getTime())) {
    return false;
  }
  
  return targetDate < now;
};

/**
 * 格式化时间为HH:mm格式
 * @param {string} timeStr - 时间字符串（如：10:00:00 或 10:00）
 * @returns {string} HH:mm格式的时间字符串
 */
export const formatTimeHHMM = (timeStr) => {
  if (!timeStr) return '';
  
  // 如果是完整的日期时间格式，提取时间部分
  if (timeStr.includes(' ')) {
    timeStr = timeStr.split(' ')[1];
  }
  
  // 如果是ISO格式，提取时间部分
  if (timeStr.includes('T')) {
    timeStr = timeStr.split('T')[1];
  }
  
  // 移除时区信息
  if (timeStr.includes('+') || timeStr.includes('-')) {
    timeStr = timeStr.split(/[+\-]/)[0];
  }
  
  // 分割时间部分
  const timeParts = timeStr.split(':');
  if (timeParts.length >= 2) {
    const hours = timeParts[0].padStart(2, '0');
    const minutes = timeParts[1].padStart(2, '0');
    return `${hours}:${minutes}`;
  }
  
  return timeStr;
};

/**
 * 获取当前东八区时间字符串
 * @returns {string} 格式化的时间字符串
 */
export const getCurrentChinaTime = () => {
  const now = new Date();
  
  // now.getTime() 本身就是UTC时间戳，直接加8小时即可得到东八区时间
  const chinaTime = new Date(now.getTime() + (8 * 60 * 60 * 1000));
  
  const year = chinaTime.getFullYear();
  const month = String(chinaTime.getMonth() + 1).padStart(2, '0');
  const day = String(chinaTime.getDate()).padStart(2, '0');
  const hours = String(chinaTime.getHours()).padStart(2, '0');
  const minutes = String(chinaTime.getMinutes()).padStart(2, '0');
  const seconds = String(chinaTime.getSeconds()).padStart(2, '0');
  
  return `${year}-${month}-${day} ${hours}:${minutes}:${seconds}`;
};

/**
 * 安全创建日期对象（处理时区）
 * @param {string} dateStr - 日期字符串
 * @returns {Date} 日期对象
 */
export const createDate = (dateStr) => {
  return parseDate(dateStr);
};

export default {
  formatDate,
  getTimeAgo,
  isToday,
  isYesterday,
  isTomorrow,
  isoToLocal,
  isOverdue,
  formatTimeHHMM,
  getCurrentChinaTime,
  createDate
}; 